﻿#define _CRT_SECURE_NO_WARNINGS 1
#include"Date.h"
using namespace std;
////class Date
////{
////public:
////	int year;
////	int month;
////	int day;
////	Date()//构造函数（无参的构造函数）  注意构造函数没有返回值，不能写成 void Date()
////	{
////		cout << "Date()" << endl;
////		year = 1;
////		month = 1;
////		day = 1;
////	}
////	////构造函数支持重载
////	//Date(int _year,int _month,int _day)//构造函数（无参的构造函数）
////	//{
////	//	cout << "Date()" << endl;
////	//	year = _year;
////	//	month = _month;
////	//	day = _day;
////	//}
////	Date(int _year,int _month,int _day)
////	{
////		year = _year;
////		month = _month;
////		day = _day;
////	}
////	void Print()
////	{
////		cout << year << '/' << month << '/' << day << endl;
////	}
////};
////int main()
////{
////	//C 
////	/*
////	栈的括号匹配问题：需要频繁地调用Destroy()函数，有时可能忘记
////	*/
////	//CPP ：默认的构造函数，析构函数
////	//构造函数使用：创建对象的时候自动调用
////	//Date d1;//自动调用
////	//Date d1();//自动调用  不支持
////	//注意：用户没有自定义构造函数，编译器会默认生成一个构造函数并且调用这个函数（隐式），若果用户定义了则不生成了
////	Date d1;//创建对象的同时自动调用有参的构造函数
////	d1.Print();
////	return 0;
////}
////////////////////////////////////////////////////////////////////////
////class Stack  //定义一个Stack这样的一个类
////{
//////public:
//////	Stack()
//////	{
//////		cout << "Stack()" << endl;
//////
//////		_a = nullptr;
//////		_size = _capacity = 0;
//////	}
//////
//////	Stack(int n)
//////	{
//////		_a = (int*)malloc(sizeof(int) * n);
//////		if (nullptr == _a)
//////		{
//////			perror("malloc申请空间失败");
//////			return;
//////		}
//////
//////		_capacity = n;
//////		_size = 0;
//////	}
//////
//////	void Push(int x)
//////	{
//////		//...
//////		_a[_size++] = x;
//////	}
//////
//////	bool Empty()
//////	{
//////		// ...
//////		return _size == 0;
//////	}
//////
//////	int Top()
//////	{
//////		//...
//////		return _a[_size - 1];
//////	}
//////
//////	//...
//////	~Stack()
//////	{
//////		cout << "~Stack()" << endl;
//////		free(_a);
//////		_a = nullptr;
//////		_size = _capacity = 0;
//////	}
////
////private:
////	// 成员变量
////	int* _a;
////	int _size;
////	int _capacity;
////};
////class MyQueue//定义一个MyQueue这样的一个类
////{
////public:
////	// 默认生成构造函数，对自定义类型成员，会调用他的默认构造函数，对于内置类型成员不做处理（就是随机值）
////	// 默认生成析构函数，对自定义类型成员，会调用他的析构函数
////
////	void push(int x) {
////
////	}
////	//....
////	//以下2个成员是自定义类型
////	Stack _pushST;
////	Stack _popST;
////	//内置类型
////	//int _size ;
////};
////int main()
////{
////	MyQueue q;
////
////	return 0;
////}
///////////////////////////////////////////////////////////////////
////class Date
////{
////public:
////	Date()//无参的构造函数
////	{
////		_year = 1900;
////		_month = 1;
////		_day = 1;
////	}
////	Date(int year = 1900, int month = 1, int day = 1)//全缺省的构造函数
////	{
////		//使用缺省值进行对内置类似的成员处理
////		_year = year;
////		_month = month;
////		_day = day;
////	}
////	void Print()
////	{
////		cout << _year << '/' << _month << '/' << _day << endl;
////	}
////private:
////	int _year;
////	int _month;
////	int _day;
////};
////int main()
////{
////	//Date d1(2024);
////	Date d1;//err
////	d1.Print();
////	return 0;
////}
////////////////////////////////////////////////////////////////////////////
////class Stack
////{
////
////public:
////	int* _a;
////	int _size;
////	int _capacity;
////	Stack()
////	{
////		int* tmp = (int*)malloc(sizeof(int) * 4);
////		if (tmp == nullptr)
////		{
////			perror("malloc fail");
////			return;
////		}
////		_a = tmp;
////		_size = 0;
////		_capacity = 4;
////	}
////	void Push(int  x)
////	{
////		// CheckCapacity();
////		_a[_size] = x;
////		_size++;
////	}
////	~Stack()
////	{
////		free(_a);
////		_a = nullptr;
////		_size = _capacity = 0;
////	}
////};
////int main()
////{
////	//析构函数:析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
////	Stack st1;
////	st1.Push(1);
////	st1.Push(2);
////	st1.Push(3);
////	return 0;
////}
////class Time
////{
////public:
////	~Time()
////	{
////		cout << "~Time()" << endl;//以此验证编译器是否调用当前析构函数
////	}
////private:
////	int _hour;
////	int _minute;
////	int _second;
////};
////class Date
////{
////private:
////	// 基本类型(内置类型)
////	int _year = 1970;
////	int _month = 1;
////	int _day = 1;
////	// 自定义类型
////	Time _t;
////};
////int main()
////{
////	// 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如
////	//有资源申请时，一定要写，否则会造成资源泄漏
////	Date d;
////	return 0;
////}
///////////////////////////////////////////////////////////////
////class Date
////{
////public:
////	int _year;
////	int _month;
////	int _day;
////	Date(int year = 2024, int month = 3, int day = 22) //全缺省 的构造参数
////	{
////		_year = year;
////		_month = month;
////		_day = day;
////	}
////	//本质 ：d2 = d1 进行赋值
////	//Date( const Date& d) //拷贝构造函数参数类型：必须是类的引用
////	//{
////	//	//this 指针指向d2,d是d1 的引用
////	//	_year = d._year;
////	//	_month = d._month;
////	//	_day = d._day;
////	//}
////};
////int main()
////{
////	//拷贝构造函数
////	//1拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存
////	//在的类类型对象创建新对象时由编译器自动调用。
//////2 拷贝构造函数的参数只有一个且必须是类类型对象的引用(注：采用传值传参，会出现无限递归的情况)
//////若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
////	Date d1;
////	Date d2(d1);
////	return 0;
////}
////typedef int DataType;
////class Stack
////{
////public:
////	Stack(size_t capacity = 10)//全缺省参数的构造函数
////	{
////		_array = (DataType*)malloc(capacity * sizeof(DataType));
////		if (nullptr == _array)
////		{
////			perror("malloc申请空间失败");
////			return;
////		}
////			_size = 0;
////		_capacity = capacity;
////	}
////	void Push(const DataType& data)
////	{
////		// ..空间容量检查
////		_array[_size] = data;
////		_size++;
////	}
////	~Stack()//析构函数
////	{
////		if (_array)
////		{
////			free(_array);
////			_array = nullptr;
////			_capacity = 0;
////			_size = 0;
////		}
////	}
////private:
////	DataType* _array;
////	size_t _size;
////	size_t _capacity;
////};
////int main()
////{
////	Stack s1;
////	s1.Push(1);
////	s1.Push(2);
////	s1.Push(3);
////	s1.Push(4);
////	Stack s2(s1);
//////类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
////	return 0;
////}
//////////////////////////////////////////////////
////class Date
////{
////public:
////	Date(int year, int minute, int day)
////	{
////		cout << "Date(int,int,int):" << this << endl;
////	}
////	Date(const Date& d)
////	{
////		cout << "Date(const Date& d):" << this << endl;
////	}
////	~Date()
////	{
////		cout << "~Date():" << this << endl;
////	}
////private:
////	int _year;
////	int _month;
////	int _day;
////};
////Date Test(Date d)
////{
////	Date temp(d);//用已经存在的对象d初始化temp，就需要调用拷贝构造函数
////	cout << "&temp:" << &temp << endl;
////	return temp;
//////返回类型：是一个类，就需要调用拷贝构造函数，注意此时虽然是返回一个局部变量,但是编译器是借助创建一个临时变量来返回的 
////}
////int main()
////{
//////拷贝构造函数适应场景：1）已经存在的类对象创建一个新的类对象 2）函数返回类型是类的 3）函数参数类型：类的类型
////	Date d1(2022, 1, 13);
////	//调用构造函数创建d1这个对象，注意拷贝函数是一个特殊的构造函数（构造函数的一个重载）
////	cout << "&d1:" << &d1 << endl;
////	Test(d1);//传值传参，就需要调用拷贝 构造函数
////	return 0;
////}
////////////////////////////////////////////////////////////////
////// 运算符重载
////class Date
////{
////public:
////	int _year;
////	int _month;
////	int _day;
////	Date(int year = 2024, int month = 3, int day = 22)//全缺省的构造参数
////	{
////		_year = year;
////		_month = month;
////		_day = day;
////	}
////	void Print()
////	{
////		cout << _year << '/' << _month << "/" << _day << endl;
////	}
////	// d1 == d2 
////	bool operator== ( Date& d2) 
////	//注意当写在类里面，默认有一个隐藏的this指针,指向左操数的地址（也就是说在传参的时候，总会比实际要少传一个参数）
////	{
////		return _year == d2._year
////			&& _month == d2._month
////			&& _day == d2._day;
////	}
////	// d1 != d2
////	bool operator!= (Date& d2)
////	{
////		//学会复用之前的代码：关键保证之前代码没有问题
////		return !(*this == d2);
////	}
////	bool operator>(Date& d2)
////	{
////		if ((*this)._year > d2._year) //注意当前*this最好不要加上（暴露新手）
////			return true;
////		else if ((*this)._year == d2._year && (*this)._month > d2._month)
////			return true;
////		else if ((*this)._year == d2._year && (*this)._month == d2._month && (*this)._day > d2._day)
////			return true;
////		else
////			return false;
////
////	}
////	bool operator<(Date& d2)
////	{
////		if (_year < d2._year) //注意当前*this最好不要加上（暴露新手）
////			return true;
////		else if (_year == d2._year && _month < d2._month)
////			return true;
////		else if (_year == d2._year &&_month == d2._month && _day < d2._day)
////			return true;
////		else
////			return false;
////
////	}
////	bool operator>=(Date& d2)
////	{
////		//不就是对<的结果取反嘛
////		return !(*this < d2);
////	}
////	bool operator<=(Date& d2)
////	{
////		//不就是对>的结果取反嘛
////		return !(*this > d2);
////	}
////	Date& operator= (Date& d2)
////	{
////		if (this != &d2)//注意这里是对d2取地址
////		{
////			_year = d2._year;
////			_month = d2._month;
////			_day = d2._day;
////		}
////		return *this;
////	}
////};
//////bool operator== (Date& d1, Date& d2) //全局的运算符重载函数
//////{
//////	return d1._year == d2._year
//////		&& d1._month == d2._month
//////		&& d1._day == d2._day;
//////}
////int main()
////{
//////C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，
//////也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
//////函数名字为：关键字operator后面接需要重载的运算符符号。
//////函数原型：返回值类型 operator操作符(参数列表)
////	Date d1(2056, 8, 14);
////	Date d2(2029,3,14);
////	cout << (d1 == d2) << endl;//注意 d1 == d2必须加上（）,涉及到优先级问题
////	//注意编译器会默认转换成 operator==(d1,d2);这个函数
////	//Date d3 = d2 = d1;//err 赋值运算符重载的本质：已经实例化的对象之间进行赋值，此时的d3并没有实例化完成
////	//Date d3;
////	//d3 = d2 = d1;
////
////	//d3.Print();
////	//d2.Print();
//////	//d1.Print();
//////	return 0;
//////}
////class Date;
////int ReturnMonthDay(Date d);
////class Date
////{
////public:
////	int _year;
////	int _month;
////	int _day;
////	void Print()
////	{
////		cout << _year << '/' << _month << '/' << _day << endl;
////	}
////	Date(int year = 2024, int month = 3, int day = 24)
////	{
////		_year = year;
////		_month = month;
////		_day = day;
////	}
////	 Date operator+(int day)
////	{
////		 //Date tmp = *this;//避免下次调用参考对象改变 err
////		 Date tmp ( *this);//应该是调用拷贝构造函数来进行初始化tmp
////		 tmp += day;
////		 return tmp ;
////	}
////	Date GetDate(Date d, int& day)
////	{
////		Date tmp ;
////		tmp = d.operator+(day);
////		while (tmp._month > ReturnMonthDay(tmp))
////		{
////			tmp._month++;
////			tmp._day -= ReturnMonthDay(tmp);
////			if (d._month >= 13)
////			{
////				d._year += 1;
////				d._month = 1;
////			}
////		}
////		return tmp;
////	}
////};
////int ReturnMonthDay(Date d)
////{
////	int MonrhDay[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
////	//判断是否为闰年
////	if ((d._year % 4 == 0 && d._year % 100 != 0) || (d._year % 400 == 0))
////	{
////		MonrhDay[2] += 1;//29天 
////	}
////	return MonrhDay[d._month];
////}
////
////int main()
////{
////	//实现一个日期 类的加法器：日期+天数 （涉及到进位的问题）
////	Date d(2024,3,25);
////	int day = 50;
////	Date ret = d.GetDate(d, day);
////	cout << ret._year << '/' << ret._month << '/' << ret._day << endl;
////	return 0;
////}
//// /////////////////////////////////////////////////////////////////////////////////////////////////////
////void test1()
////{
////	Date d1(2024, 3, 25);
////	Date d2 = (d1 + 1000);//对d2进行实例化
////	//Date d3 (d1 += 1000);
////	d1.Print();
////	d2.Print();
////	//d3.Print();
////
////
////}
////
////int main1()
////{
////	test1();
////	return 0;
////}
////class Time
////{
////public:
////	int _hour;
////	int _min;
////	int _sec;
////	Time(int hour = 22, int min = 22, int sec = 22)//全缺省的构造函数
////	{
////		_hour = hour;
////		_min = min;
////		_sec = sec;
////	}
////	Time(const Time& t)//拷贝构造函数
////	{
////		_hour = t._hour;
////		_min = t._min;
////		_sec = t._sec;
////	}
////	void operator=(Time t)//+这个运算符重载
////	{
////		_hour = t._hour;
////		_min = t._min;
////		_sec = t._sec;
////	}
////	
////};
////int main2()
////{
////	Time t1(22, 12, 20);
////	Time t2;
////	t2 = t1;
////	cout<<"t1"<<':' << t1._hour << ':' << t1._min << ':' << t1._sec << endl;
////	cout<<"t2" <<':' << t2._hour << ':' << t2._min << ':' << t2._sec << endl;
////
////	return 0;
////}
////class Stack
////{
////public:
////	int  capacity;
////	int top;
////	int* a;
////
////};
////class MyQueue
////{
////public:
////	int _size = 0;
////	Stack _push;
////	Stack _pop;
////	//对于这个类就不需要自己手写拷贝构造函数
////
////};
////int main3()
////{
////	//什么时候需要自己手写拷贝构造函数：调用的析构函数进行空间的释放，就需要手写
////	return 0;
////}
////class Date
////{
////public:
////	int _year;
////	int _month;
////	int _day;
////	void Print()
////	{
////		cout << _year << '/' << _month << '/' << _day << endl;
////	}
////	Date(int year = 2024, int month = 3, int day = 26)//全缺省的构造函数（对于内置类型不做处理，对于自定义类型做处理）
////	{
////		_year = year;
////		_month = month;
////		_day = day;
////	}
////	//注意对于Date这个类不需要写拷贝构造函数，编译器可以进行处理
////	Date(const Date& d)//拷贝构造函数（对应内置类型是做浅层拷贝，自定义类型深层拷贝）
////	{
////		_year = d._year;
////		_month = d._month;
////		_day = d._day;
////	}
////	// d1 > d2 *this 默认指向运算符的左操数，此时d是d2的引用
////	bool operator>(const Date& d)
////	{
////		if (_year > d._year)
////		{
////			return true;
////		}
////		else if (_year == d._year && _month > d._month)
////		{
////			return  true;
////		}
////		else if (_year == d._year && _month == d._month && _day > d._day)
////		{
////			return true;
////		}
////		else 
////			return false;
////	}
////	// d1 == d2
////	bool operator==(const Date& d)
////	{
////		return _year == d._year && _month == d._month && _day == d._day;
////	}
////	bool operator!=(const Date& d)
////	{
////		//直接复用之前代码
////		return !(*this == d);
////	}
////	//d1 >= d2 ===> d1 > d2 || d1 == d2
////	bool operator>=(const Date& d)
////	{
////		return(((*this) > d) || (*this) == d);
////	}
////	// d1 <= d2
////	bool operator<= (const Date& d)
////	{
////		//对 . 进行取反
////		return !(*this > d);
////	}
////};
////int main()
////{
////	Date d1(2024, 11,26);//调用构造函数进行实例化
////	Date d2;// 只不过是用全缺省函数进行初始化
////	cout << (d1 <= d2) << endl;//编译器会自动转换成调用这个!= 运算符重载函数 d1.operator(d2)
////
////	return 0;
////}
//void test()
//{
//	Date d1(2024, 3, 27);
//	//d1 += 50;
//	//d1.Print();
//	//d1 += 1000;
//	//d1.Print();
//	Date d2(d1 + 50);
//	Date d3(d1 + 1000);
//	Date d4(d1 + 10000);
//	/*d2.Print();
//	d3.Print();
//	d4.Print();*/
//	//Date d22 = d1++;//注意这是调用拷贝构造函数，而不是调用赋值重载函数
//	//Date d22 = d1.operator++(1);//注意这是调用拷贝构造函数，而不是调用赋值重载函数
//
//	//d22.Print();
//	//d1.Print();
//	 d2 = (d1++);//编译器会自动转换成调用后置++这个运算符重载的函数
//	d2.Print();
//}
void test1()
{
	//Date d1(2024, 2, 15);
	////Date d2(2024, 1, 18);
	//Date d2(d1 -= 50000);//对d2进行初始化
	//d2.Print();
	//Date d3(d1 -= 50);// 2023,12,27
	//d3.Print();
	Date d1(2024, 2, 15);
	//Date d2(2024, 1, 18);
	Date d2(d1 );//对d2进行初始化
	d2 -= -50;
	d2.Print();
	Date d3(d1);//对d2进行初始化
	d3 += -50;
	

}
//void test2()
//{
//	Date d1(2024, 3, 29);
//	Date d2(1891,4,12);
//	int ret = d1 - d2;
//	cout << ret << endl;
//}
int main11()
{
	//test();
	test1();
	//test2();
	return  0;
}
//void fun1(const Date& d) //注意此时的对象有const修饰，调用成员函数进行操作的时候必须是const成员函数，否则编译不过去
//{
//	d.Print();
//}
//int main()
//{
//	//将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
//	Date d1(2024,3,30);
//	d1.Print();//非const对象调用const成员函数是权限缩小：只能进行读的操作
//	const Date d2(2024, 3, 31);
//	d2.Print();//编译器自动调用  Print() const
//	cout << d1.operator&() << endl;;
//	cout << d2.operator&() << endl;;
//	return 0;
//}
int main()
{
	Date d(2024, 3, 30);

	return 0;
}